/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include <基本类型.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>


typedef enum {
	JSON_STRING,
	JSON_NUMBER,
	JSON_OBJECT,
	JSON_ARRAY,
	JSON_BOOLEAN,
	JSON_NULL
} JSONValueType;

//typedef struct JSONValueNode {
//	char* key;
//	JSONValueType type;
//	union {
//		char* string_value;
//		double number_value;
//		struct JSONValueNode* object_value;
//		struct JSONValueNode* array_value;
//		int boolean_value;
//	};
//	struct JSONValueNode* next;
//} JSONValueNode;
//
//JSONValueNode* parseJSONObject(const char** jsonString);
//JSONValueNode* parseJSONArray(const char** jsonString);
//char* parseJSONString(const char** jsonString);
//double parseJSONNumber(const char** jsonString);
//int parseJSONBoolean(const char** jsonString);
//
//
//
//
//// 解析JSON字符串
//char* parseJSONString(const char** jsonString) {
//	char* result = NULL;
//	const char* ptr = *jsonString;
//
//	if (*ptr != '\"') {
//		// JSON字符串应以引号开始
//		return NULL;
//	}
//	ptr++; // 跳过引号
//
//	size_t len = 0;
//	const char* start = ptr;
//	while (*ptr != '\"' && *ptr != '\0') {
//		// 处理Unicode字符的转义，例如 \uXXXX
//		if (*ptr == '\\' && *(ptr + 1) == 'u') {
//			// 解析Unicode字符
//			// 这部分代码需要根据解析规则和具体的处理方式进行实现
//			// 将解析后的Unicode字符添加到result中
//			// 示例中直接将Unicode字符原样添加到result中
//			ptr += 2; // 跳过\u
//			len += 6; // Unicode字符将会被替换为6个字符
//			result = (char*)realloc(result, len + 1);
//			memcpy(result + len - 6, ptr, 6);
//			ptr += 6; // 跳过Unicode字符
//		}
//		else {
//			len++; // 非转义字符
//			result = (char*)realloc(result, len + 1);
//			result[len - 1] = *ptr;
//			ptr++;
//		}
//	}
//
//	if (*ptr == '\0') {
//		// JSON字符串没有以引号结束
//		free(result);
//		return NULL;
//	}
//
//	ptr++; // 跳过引号
//	result[len] = '\0'; // 添加字符串结尾的空字符
//	*jsonString = ptr; // 更新jsonString指针的值
//	return result;
//}
//
//// 解析JSON数字
//double parseJSONNumber(const char** jsonString) {
//	const char* ptr = *jsonString;
//	bool isNegative = false;
//	double result = 0.0;
//
//	if (*ptr == '-') {
//		isNegative = true;
//		ptr++;
//	}
//
//	while (*ptr >= '0' && *ptr <= '9') {
//		result = result * 10 + (*ptr - '0');
//		ptr++;
//	}
//
//	if (*ptr == '.') {
//		double fraction = 0.1;
//		ptr++;
//
//		while (*ptr >= '0' && *ptr <= '9') {
//			result = result + (*ptr - '0') * fraction;
//			fraction /= 10.0;
//			ptr++;
//		}
//	}
//
//	if (isNegative) {
//		result = -result;
//	}
//
//	*jsonString = ptr; // 更新jsonString指针的值
//	return result;
//}
//
//// 解析JSON布尔值
//int parseJSONBoolean(const char** jsonString) {
//	const char* ptr = *jsonString;
//	int result = 0;
//
//	if (strncmp(ptr, "true", 4) == 0) {
//		result = 1;
//		ptr += 4;
//	}
//	else if (strncmp(ptr, "false", 5) == 0) {
//		result = 0;
//		ptr += 5;
//	}
//
//	*jsonString = ptr; // 更新jsonString指针的值
//	return result;
//}
//
//
//
//
//// 解析JSON数组
//JSONValueNode* parseJSONArray(const char** jsonString) {
//	JSONValueNode* valueNode = NULL;
//	JSONValueNode* tailNode = NULL;
//
//	(*jsonString)++; // 忽略开头的方括号
//
//	while (**jsonString != '\0' && **jsonString != ']') {
//		(*jsonString)++;
//
//		JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
//		node->key = NULL;
//		node->type = JSON_NULL;
//		node->next = NULL;
//
//		if (**jsonString == '{') {
//			node->type = JSON_OBJECT;
//			node->object_value = parseJSONObject(jsonString);
//		}
//		else if (**jsonString == '[') {
//			node->type = JSON_ARRAY;
//			node->array_value = parseJSONArray(jsonString);
//		}
//		else if (**jsonString == '\"') {
//			node->type = JSON_STRING;
//			node->string_value = parseJSONString(jsonString);
//		}
//		else if (**jsonString == '-' || (**jsonString >= '0' && **jsonString <= '9')) {
//			node->type = JSON_NUMBER;
//			node->number_value = parseJSONNumber(jsonString);
//		}
//		else if (**jsonString == 't' || **jsonString == 'f') {
//			node->type = JSON_BOOLEAN;
//			node->boolean_value = parseJSONBoolean(jsonString);
//		}
//		else if (**jsonString == 'n') {
//			node->type = JSON_NULL;
//			(*jsonString) += 3; // 跳过 "null"
//		}
//
//		// 连接节点
//		if (valueNode == NULL) {
//			valueNode = node;
//			tailNode = node;
//		}
//		else {
//			tailNode->next = node;
//			tailNode = node;
//		}
//
//		// 忽略逗号
//		if (**jsonString == ',') {
//			(*jsonString)++;
//		}
//	}
//
//	(*jsonString)++; // 忽略结尾的方括号
//
//	return valueNode;
//}
//
//// 解析JSON对象
//JSONValueNode* parseJSONObject(const char** jsonString) {
//	JSONValueNode* valueNode = NULL;
//	JSONValueNode* tailNode = NULL;
//
//	(*jsonString)++; // 忽略开头的大括号
//
//	while (**jsonString != '\0' && **jsonString != '}') {
//		(*jsonString)++;
//
//		// 解析键
//		char* key = parseJSONString(jsonString);
//
//		(*jsonString)++; // 忽略冒号
//
//		// 解析值
//		JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
//		node->key = key;
//		node->type = JSON_NULL;
//		node->next = NULL;
//
//		if (**jsonString == '{') {
//			node->type = JSON_OBJECT;
//			node->object_value = parseJSONObject(jsonString);
//		}
//		else if (**jsonString == '[') {
//			node->type = JSON_ARRAY;
//			node->array_value = parseJSONArray(jsonString);
//		}
//		else if (**jsonString == '\"') {
//			node->type = JSON_STRING;
//			node->string_value = parseJSONString(jsonString);
//		}
//		else if (**jsonString == '-' || (**jsonString >= '0' && **jsonString <= '9')) {
//			node->type = JSON_NUMBER;
//			node->number_value = parseJSONNumber(jsonString);
//		}
//		else if (**jsonString == 't' || **jsonString == 'f') {
//			node->type = JSON_BOOLEAN;
//			node->boolean_value = parseJSONBoolean(jsonString);
//		}
//		else if (**jsonString == 'n') {
//			node->type = JSON_NULL;
//			(*jsonString) += 3; // 跳过 "null"
//		}
//
//		// 连接节点
//		if (valueNode == NULL) {
//			valueNode = node;
//			tailNode = node;
//		}
//		else {
//			tailNode->next = node;
//			tailNode = node;
//		}
//
//		// 忽略逗号
//		if (**jsonString == ',') {
//			(*jsonString)++;
//		}
//	}
//
//	(*jsonString)++; // 忽略结尾的大括号
//
//	return valueNode;
//}






typedef struct JSONValueNode {
	char* key;
	JSONValueType type;
	union {
		char* string_value;
		double number_value;
		struct JSONValueNode* object_value;
		struct JSONValueNode* array_value;
		int boolean_value;
	};
	struct JSONValueNode* next;
	struct JSONValueNode* child;  // 新增一个指向子级的指针
} JSONValueNode;


// JSON value structure
typedef struct {
	JSONValueType type;
	union {
		char* string_val;
		double number_val;
		struct json_object* object_val;
		struct json_array* array_val;
		int boolean_val;
	} data;
} json_value;





// 创建字符串类型的JSON值节点
Inline JSONValueNode* createJSONString(const char* key, const char* value) {
	JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
	node->type = JSONValueType::JSON_STRING;
	node->key = strdup(key);
	node->string_value = strdup(value);
	node->next = nullptr;
	node->child = nullptr;
	return node;
}

// 创建数字类型的JSON值节点
Inline JSONValueNode* createJSONNumber(const char* key, double value) {
	JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
	node->type = JSONValueType::JSON_NUMBER;
	node->key = strdup(key);
	node->number_value = value;
	node->next = NULL;
	node->child = NULL;
	return node;
}

// 创建布尔类型的JSON值节点
Inline JSONValueNode* createJSONBoolean(const char* key, int value) {
	JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
	node->type = JSONValueType::JSON_BOOLEAN;
	node->key = strdup(key);
	node->boolean_value = value;
	node->next = NULL;
	node->child = NULL;
	return node;
}

// 创建空类型的JSON值节点
Inline JSONValueNode* createJSONNull(const char* key) {
	JSONValueNode* node = (JSONValueNode*)malloc(sizeof(JSONValueNode));
	node->type = JSONValueType::JSON_NULL;
	node->key = strdup(key);
	node->next = NULL;
	node->child = NULL;
	return node;
}

// 递归写入JSON数据
Inline void writeJSONDataRecursive(FILE* file, JSONValueNode* json, int indent_level) {
	for (int i = 0; i < indent_level; i++) {
		fprintf(file, "\t");
	}

	if (json->key != NULL) {
		fprintf(file, "\"%s\": ", json->key);
	}

	switch (json->type) {
		case JSON_STRING:
			fprintf(file, "\"%s\"", json->string_value);
			break;
		case JSON_NUMBER:
			fprintf(file, "%f", json->number_value);
			break;
		case JSON_BOOLEAN:
			fprintf(file, "%s", json->boolean_value ? "true" : "false");
			break;
		case JSON_NULL:
			fprintf(file, "null");
			break;
		case JSON_OBJECT: {
			fprintf(file, "{\n");
			JSONValueNode* child = json->child;
			while (child != NULL) {
				writeJSONDataRecursive(file, child, indent_level + 1);
				if (child->next != NULL) {
					fprintf(file, ",\n");
				}
				else {
					fprintf(file, "\n");
				}
				child = child->next;
			}
			for (int i = 0; i < indent_level; i++) {
				fprintf(file, "\t");
			}
			fprintf(file, "}");
			break;
		}
			
		case JSON_ARRAY: {
			fprintf(file, "[");
			JSONValueNode* element = json->child;
			while (element != NULL) {
				writeJSONDataRecursive(file, element, indent_level);
				if (element->next != NULL) {
					fprintf(file, ", ");
				}
				element = element->next;
			}
			fprintf(file, "]");
			break;
		}
			
		default:
			printf("未知的JSON值类型\n");
			break;
	}
}

// 将JSON数据写入文件
Inline void writeJSONDataToFile(const char* filename, JSONValueNode* json) {
	FILE* file = fopen(filename, "w");

	if (file == NULL) {
		printf("无法打开文件: %s\n", filename);
		return;
	}

	writeJSONDataRecursive(file, json, 0);
	fprintf(file, "\n");

	fclose(file);
}







// JSON object structure
typedef struct json_object {
	char* key;
	json_value* value;
	struct json_object* next;
} json_object;

// JSON array structure
typedef struct json_array {
	json_value* value;
	struct json_array* next;
} json_array;

// Function to parse JSON string and return JSON value
json_value* parse_json(const char* json);

// Function to free dynamically allocated JSON value
void free_json_value(json_value* value);

// JSON parse helpers
static json_value* parse_json_object(const char** json);
static json_value* parse_json_array(const char** json);
static json_value* parse_json_string(const char** json);
static json_value* parse_json_number(const char** json);
static json_value* parse_json_boolean(const char** json);
static json_value* parse_json_null(const char** json);

// Helper function to skip whitespace characters
static void skip_whitespace(const char** json) {
	while (**json && (**json == ' ' || **json == '\t' || **json == '\n' || **json == '\r'))
		(*json)++;
}

// Helper function to parse JSON string
static char* parse_string(const char** json) {
	char* str = NULL;
	const char* ptr = *json + 1;
	const char* end_ptr = ptr;
	int length = 0;

	while (*end_ptr && *end_ptr != '\"') {
		if (*end_ptr == '\\')
			end_ptr++;
		end_ptr++;
		length++;
	}

	str = (char*)malloc(sizeof(char) * (length + 1));

	length = 0;
	while (*ptr && *ptr != '\"') {
		if (*ptr == '\\') {
			ptr++;
			switch (*ptr) {
				case '\"': str[length++] = '\"'; break;
				case '\\': str[length++] = '\\'; break;
				case '/':  str[length++] = '/'; break;
				case 'b':  str[length++] = '\b'; break;
				case 'f':  str[length++] = '\f'; break;
				case 'n':  str[length++] = '\n'; break;
				case 'r':  str[length++] = '\r'; break;
				case 't':  str[length++] = '\t'; break;
				case 'u':
					// Handle Unicode escape sequence if needed
					// Not implemented in this example
					break;
				default:
					// Handle other escape sequences if needed
					// Not implemented in this example
					break;
			}
		}
		else {
			str[length++] = *ptr;
		}
		ptr++;
	}

	str[length] = '\0';

	*json = end_ptr + 1;

	return str;
}

// Helper function to parse JSON number
Inline static double parse_number(const char** json) {
	double number = 0.0;
	sscanf(*json, "%lf", &number);
	while (**json && (**json == '-' || **json == '+' || **json == '.' || (**json >= '0' && **json <= '9') || **json == 'e' || **json == 'E')) {
		(*json)++;
	}
	return number;
}

// Helper function to create and initialize JSON value with given type
Inline static json_value* create_json_value(JSONValueType type) {
	json_value* value = (json_value*)malloc(sizeof(json_value));
	value->type = type;
	return value;
}

Inline json_value* parse_json(const char* json) {
	skip_whitespace(&json);

	switch (*json) {
		case '{': return parse_json_object(&json);
		case '[': return parse_json_array(&json);
		case '\"': return parse_json_string(&json);
		case 't': case 'f': return parse_json_boolean(&json);
		case 'n': return parse_json_null(&json);
		default: return parse_json_number(&json);
	}
}

Inline void free_json_value(json_value* value) {
	if (!value) return;

	switch (value->type) {
		case JSON_STRING:
			free(value->data.string_val);
			break;
		case JSON_OBJECT:
			while (value->data.object_val) {
				json_object* current = value->data.object_val;
				value->data.object_val = current->next;
				free(current->key);
				free_json_value(current->value);
				free(current);
			}
			break;
		case JSON_ARRAY:
			while (value->data.array_val) {
				json_array* current = value->data.array_val;
				value->data.array_val = current->next;
				free_json_value(current->value);
				free(current);
			}
			break;
		default:
			break;
	}

	free(value);
}

Inline static json_value* parse_json_object(const char** json) {
	json_object* head = NULL;
	json_object* tail = NULL;
	json_value* value = NULL;

	(*json)++; // Skip '{'
	skip_whitespace(json);

	if (**json == '}') {
		(*json)++; // Skip '}'
		return create_json_value(JSON_OBJECT);
	}

	while (**json) {
		skip_whitespace(json);

		// Parse key
		char* key = parse_string(json);

		skip_whitespace(json);

		if (**json != ':') {
			// Syntax error
			free(key);
			return NULL;
		}

		(*json)++; // Skip ':'
		skip_whitespace(json);

		// Parse value
		value = parse_json(*json);
		if (!value) {
			free(key);
			return NULL;
		}

		// Create new JSON object
		json_object* new_object = (json_object*)malloc(sizeof(json_object));
		new_object->key = key;
		new_object->value = value;
		new_object->next = NULL;

		// Add the new object to the list
		if (!head) {
			head = new_object;
			tail = new_object;
		}
		else {
			tail->next = new_object;
			tail = new_object;
		}

		value = NULL;

		skip_whitespace(json);

		if (**json == ',') {
			(*json)++; // Skip ','
			continue;
		}
		else if (**json == '}') {
			(*json)++; // Skip '}'
			break;
		}
		else {
		 // Syntax error
			return NULL;
		}
	}

	// Create the JSON object value
	json_value* object_value = create_json_value(JSON_OBJECT);
	object_value->data.object_val = head;

	return object_value;
}

Inline static json_value* parse_json_array(const char** json) {
	json_array* head = NULL;
	json_array* tail = NULL;
	json_value* value = NULL;

	(*json)++; // Skip '['
	skip_whitespace(json);

	if (**json == ']') {
		(*json)++; // Skip ']'
		return create_json_value(JSON_ARRAY);
	}

	while (**json) {
		skip_whitespace(json);

		// Parse value
		value = parse_json(*json);
		if (!value)
			return NULL;

		// Create new JSON array
		json_array* new_array = (json_array*)malloc(sizeof(json_array));
		new_array->value = value;
		new_array->next = NULL;

		// Add the new array to the list
		if (!head) {
			head = new_array;
			tail = new_array;
		}
		else {
			tail->next = new_array;
			tail = new_array;
		}

		value = NULL;

		skip_whitespace(json);

		if (**json == ',') {
			(*json)++; // Skip ','
			continue;
		}
		else if (**json == ']') {
			(*json)++; // Skip ']'
			break;
		}
		else {
		 // Syntax error
			return NULL;
		}
	}

	// Create the JSON array value
	json_value* array_value = create_json_value(JSON_ARRAY);
	array_value->data.array_val = head;

	return array_value;
}

Inline static json_value* parse_json_string(const char** json) {
	char* value = parse_string(json);
	if (!value)
		return NULL;
	json_value* string_value = create_json_value(JSON_STRING);
	string_value->data.string_val = value;
	return string_value;
}

Inline static json_value* parse_json_number(const char** json) {
	double value = parse_number(json);
	json_value* number_value = create_json_value(JSON_NUMBER);
	number_value->data.number_val = value;
	return number_value;
}

Inline static json_value* parse_json_boolean(const char** json) {
	JSONValueType type = (**json == 't') ? JSON_BOOLEAN : JSON_NULL;
	int length = (type == JSON_BOOLEAN) ? 4 : 3;
	if (strncmp(*json, (type == JSON_BOOLEAN) ? "true" : "null", length) != 0) {
		// Syntax error
		return NULL;
	}
	*json += length;
	json_value* boolean_value = create_json_value(type);
	boolean_value->data.boolean_val = (type == JSON_BOOLEAN) ? 1 : 0;
	return boolean_value;
}

Inline static json_value* parse_json_null(const char** json) {
	if (strncmp(*json, "null", 4) != 0) {
		// Syntax error
		return NULL;
	}
	*json += 4;
	return create_json_value(JSON_NULL);
}









//int main() {
//	JSONValueNode* root = createJSONString(NULL, NULL);  // 创建根节点
//
//	JSONValueNode* person = createJSONString("姓名", "张三");
//	person->next = createJSONNumber("年龄", 25);
//	person->next->next = createJSONBoolean("已婚", 1);
//	person->next->next->next = createJSONNull("职业");
//
//	JSONValueNode* address = createJSONString("城市", "北京");
//	address->next = createJSONString("街道", "中关村");
//	address->next->next = createJSONNumber("邮编", 100000);
//
//	person->child = address;  // person节点的子节点是address节点
//
//	root->child = person;  // root节点的子节点是person节点
//
//	writeJSONDataToFile("example.json", root);
//
//	// 释放内存
//	while (root != NULL) {
//		JSONValueNode* temp = root;
//		root = root->next;
//		free(temp->key);
//		if (temp->type == JSON_STRING)
//			free(temp->string_value);
//		if (temp->type == JSON_OBJECT || temp->type == JSON_ARRAY) {
//			JSONValueNode* child = temp->child;
//			while (child != NULL) {
//				JSONValueNode* child_temp = child;
//				child = child->next;
//				free(child_temp->key);
//				if (child_temp->type == JSON_STRING)
//					free(child_temp->string_value);
//				free(child_temp);
//			}
//		}
//		free(temp);
//	}
//
//	return 0;
//}




//int main() {
//    const char* jsonString = "{ \"key1\": \"value1\", \"key2\": { \"nestedKey\": \"nestedValue\" }, \"key3\": 3.14159, \"key4\": true, \"key5\": null, \"key6\": [1, 2, 3] }";
//
//    // 解析JSON对象
//    JSONValueNode* valueNode = parseJSONObject(&jsonString);
//		
//    // 打印解析结果示例
//    printf("解析结果示例:\n");
//    JSONValueNode* currentNode = valueNode;
//    while (currentNode != NULL) {
//        printf("键: %s\n", currentNode->key);
//        printf("值类型: %d\n", currentNode->type);
//        switch (currentNode->type) {
//            case JSON_STRING:
//                printf("字符串值: %s\n", currentNode->string_value);
//                break;
//            case JSON_NUMBER:
//                printf("数字值: %lf\n", currentNode->number_value);
//                break;
//            case JSON_BOOLEAN:
//                printf("布尔值: %s\n", currentNode->boolean_value ? "true" : "false");
//                break;
//            case JSON_OBJECT:
//                printf("对象值: <递归打印JSON对象>\n");
//                break;
//            case JSON_ARRAY:
//                printf("数组值: <递归打印JSON数组>\n");
//                break;
//            case JSON_NULL:
//                printf("空值\n");
//                break;
//        }
//
//        currentNode = currentNode->next;
//    }
//
//    // 释放内存
//    JSONValueNode* tempNode = NULL;
//    currentNode = valueNode;
//    while (currentNode != NULL) {
//        free(currentNode->key);
//        if (currentNode->type == JSON_STRING) {
//            free(currentNode->string_value);
//        }
//        else if (currentNode->type == JSON_OBJECT || currentNode->type == JSON_ARRAY) {
//         // 递归释放对象或数组值的内存
//            tempNode = currentNode->object_value;
//            while (tempNode != NULL) {
//                JSONValueNode* nextNode = tempNode->next;
//                free(tempNode->key);
//                free(tempNode);
//                tempNode = nextNode;
//            }
//        }
//        tempNode = currentNode->next;
//        free(currentNode);
//        currentNode = tempNode;
//    }
//
//    return 0;
//}


